.TH std::forward_as_tuple 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::forward_as_tuple \- std::forward_as_tuple

.SH Synopsis
   Defined in header <tuple>
   template< class... Types >                                   \fI(since C++11)\fP
   tuple<Types&&...> forward_as_tuple( Types&&... args )        (constexpr since C++14)
   noexcept;

   Constructs a tuple of references to the arguments in args suitable for forwarding as
   an argument to a function. The tuple has rvalue reference data members when rvalues
   are used as arguments, and otherwise has lvalue reference data members.

.SH Parameters

   args - zero or more arguments to construct the tuple from

.SH Return value

   A std::tuple object created as if by
   std::tuple<Types&&...>(std::forward<Types>(args)...)

.SH Notes

   If the arguments are temporaries, forward_as_tuple does not extend their lifetime;
   they have to be used before the end of the full expression.

.SH Example


// Run this code

 #include <iostream>
 #include <map>
 #include <tuple>
 #include <string>

 int main()
 {
     std::map<int, std::string> m;

     m.emplace(std::piecewise_construct,
               std::forward_as_tuple(10),
               std::forward_as_tuple(20, 'a'));
     std::cout << "m[10] = " << m[10] << '\\n';

     // The following is an error: it produces a
     // std::tuple<int&&, char&&> holding two dangling references.
     //
     // auto t = std::forward_as_tuple(20, 'a');
     // m.emplace(std::piecewise_construct, std::forward_as_tuple(10), t);
 }

.SH Output:

 m[10] = aaaaaaaaaaaaaaaaaaaa

.SH See also

   make_tuple creates a tuple object of the type defined by the argument types
   \fI(C++11)\fP    \fI(function template)\fP
   tie        creates a tuple of lvalue references or unpacks a tuple into individual
   \fI(C++11)\fP    objects
              \fI(function template)\fP
   tuple_cat  creates a tuple by concatenating any number of tuples
   \fI(C++11)\fP    \fI(function template)\fP
   apply      calls a function with a tuple of arguments
   \fI(C++17)\fP    \fI(function template)\fP
